package cn.imvc.core;

import java.io.Serializable;
import java.util.List;

import org.springframework.stereotype.Repository;

import com.puff.cache.CacheClient;
import com.puff.cache.CallBack;

@Repository
public class ICache {
	
	/**
	 * 获取缓存
	 * @param key
	 * @return
	 */
	public <T extends Serializable> T get(String cacheName, String key) {
		return CacheClient.getInstance().get(cacheName,key);
	}

	/**
	 * 获取缓存,同时删除
	 * @param key
	 * @return
	 */
	public <T extends Serializable> T getAndRemove(String cacheName, String key) {
		return CacheClient.getInstance().getAndRemove(cacheName,key);
	}

	/**
	 * 获取缓存(从一级缓存获取)
	 * @param key
	 * @return
	 */
	public <T extends Serializable> T getFirst(String cacheName, String key) {
		return CacheClient.getInstance().getFirst(cacheName,key) ;
	}

	/**
	 * 获取缓存(从一级缓存获取),同时删除
	 * @param key
	 * @return
	 */
	public <T extends Serializable> T getAndRemoveFirst(String cacheName, String key) {
		return CacheClient.getInstance().getAndRemoveFirst(cacheName,key);
	}

	/**
	 * 获取缓存(从二级缓存获取)
	 * @param key
	 * @return
	 */
	public <T extends Serializable> T getSecond(String cacheName, String key) {
		return CacheClient.getInstance().getSecond(cacheName,key);
	}

	/**
	 * 获取缓存(从二级缓存获取),同时删除
	 * @param key
	 * @return
	 */
	public <T extends Serializable> T getAndRemoveSecond(String cacheName, String key) {
		return CacheClient.getInstance().getAndRemoveSecond(cacheName,key);
	}

	/**
	 * 获取缓存
	 * @param key
	 * @return
	 */
	public <T extends Serializable> List<T> get(String cacheName, List<String> keys) {
		return CacheClient.getInstance().get(cacheName,keys);
	}

	/**
	 * 获取缓存(从一级缓存获取)
	 * @param key
	 * @return
	 */
	public <T extends Serializable> List<T> getFirst(String cacheName, List<String> keys) {
		return CacheClient.getInstance().getFirst(cacheName,keys);
	}

	/**
	 * 获取缓存(从二级缓存获取)
	 * @param key
	 * @return
	 */
	public <T extends Serializable> List<T> getSecond(String cacheName, List<String> keys) {
		return CacheClient.getInstance().getSecond(cacheName,keys);
	}


	/**
	 * 获取缓存，取不到时调用CallBack接口获取数据
	 * @param key
	 * @param callBack
	 * @return
	 */
	public <T extends Serializable> T get(String cacheName, String key, CallBack<T> callBack) {
		return CacheClient.getInstance().get(cacheName,key,callBack);
	}

	/**
	 * 获取缓存(从一级缓存获取)，取不到时调用CallBack接口获取数据
	 * @param key
	 * @param callBack
	 * @return
	 */
	public <T extends Serializable> T getFirst(String cacheName, String key, CallBack<T> callBack) {
		return CacheClient.getInstance().getFirst(cacheName,key,callBack);
	}

	/**
	 * 获取缓存(从二级缓存获取)，取不到时调用CallBack接口获取数据
	 * @param key
	 * @param callBack
	 * @return
	 */
	public <T extends Serializable> T getSecond(String cacheName, String key, CallBack<T> callBack) {
		return CacheClient.getInstance().getSecond(cacheName,key,callBack);
	}

	/**
	 * 储存缓存，key存在直接覆盖
	 * @param <T>
	 * @param key
	 * @param value
	 */
	public <T extends Serializable> void put(String cacheName, String key, T value) {
		CacheClient.getInstance().put(cacheName,key,value);
	}

	/**
	 * 储存缓存(直接储存在一级缓存)，key存在直接覆盖
	 * @param <T>
	 * @param key
	 * @param value
	 */
	public <T extends Serializable> void putFirst(String cacheName, String key, T value) {
		CacheClient.getInstance().putFirst(cacheName,key,value);
	}

	/**
	 * 储存缓存(直接储存在二级缓存)，key存在直接覆盖
	 * @param <T>
	 * @param key
	 * @param value
	 */
	public <T extends Serializable> void putSecond(String cacheName, String key, T value) {
		CacheClient.getInstance().putSecond(cacheName,key,value);
	}


	/**
	 * 储存缓存，key存在直接覆盖，同时设置超时时间
	 * @param <T>
	 * @param key
	 * @param value
	 * @param expire
	 */
	public <T extends Serializable> void put(String cacheName, String key, T value, int expire) {
		CacheClient.getInstance().put(cacheName, key, value, expire);
	}

	/**
	 * 储存缓存(直接储存在一级缓存)，key存在直接覆盖，同时设置超时时间
	 * @param <T>
	 * @param key
	 * @param value
	 * @param expire
	 */
	public <T extends Serializable> void putFirst(String cacheName, String key, T value, int expire) {
		CacheClient.getInstance().putFirst(cacheName, key,value,expire);
	}

	/**
	 * 储存缓存(直接储存在二级缓存)，key存在直接覆盖，同时设置超时时间
	 * @param <T>
	 * @param key
	 * @param value
	 * @param expire
	 */
	public <T extends Serializable> void putSecond(String cacheName, String key, T value, int expire) {
		CacheClient.getInstance().putSecond(cacheName,key,value,expire);
	}



	/**
	 * 更新缓存，保留缓存超时时间 比如a有效期10分钟 5分钟后更新a a的超时时间还是5分钟
	 * @param <T>
	 * @param key
	 * @param value
	 */
	public <T extends Serializable> void update(String cacheName, String key, T value) {
		CacheClient.getInstance().update(cacheName,key,value);
	}

	/**
	 * 更新缓存(直接操作一级缓存)，保留缓存超时时间 比如a有效期10分钟 5分钟后更新a a的超时时间还是5分钟
	 * @param <T>
	 * @param key
	 * @param value
	 */
	public <T extends Serializable> void updateFirst(String cacheName, String key, T value) {
		CacheClient.getInstance().updateFirst(cacheName,key,value);
	}

	/**
	 * 更新缓存(直接操作二级缓存)，保留缓存超时时间 比如a有效期10分钟 5分钟后更新a a的超时时间还是5分钟
	 * @param <T>
	 * @param key
	 * @param value
	 */
	public <T extends Serializable> void updateSecond(String cacheName, String key, T value) {
		CacheClient.getInstance().updateSecond(cacheName,key,value);
	}


	/**
	 * 获取缓存有效时间
	 * @param key
	 * @return
	 */
	public int ttl(String cacheName, String key) {
		return CacheClient.getInstance().ttl(cacheName,key);
	}

	/**
	 * 获取缓存有效时间(直接操作一级缓存)
	 * @param key
	 * @return
	 */
	public int ttlFirst(String cacheName, String key) {
		return CacheClient.getInstance().ttlFirst(cacheName,key);
	}

	/**
	 * 获取缓存有效时间(直接操作二级缓存)
	 * @param key
	 * @return
	 */
	public int ttlSecond(String cacheName, String key) {
		return CacheClient.getInstance().ttlSecond(cacheName,key);
	}

	/**
	 * 获取 cacheName所有key
	 * @return
	 */
	public List<String> keys(String cacheName) {
		return CacheClient.getInstance().keys(cacheName);
	}

	/**
	 * 获取 group所有key(直接操作一级缓存)
	 * @return
	 */
	public List<String> keysFirst(String cacheName) {
		return  CacheClient.getInstance().keysFirst(cacheName);
	}

	/**
	 * 获取 group所有key(直接操作二级缓存)
	 * @return
	 */
	public List<String> keysSecond(String cacheName) {
		return CacheClient.getInstance().keysSecond(cacheName);
	}

	/**
	 * 移除缓存
	 * @param key
	 */
	public void remove(String cacheName, String key) {
		 CacheClient.getInstance().remove(cacheName,key);
	}

	/**
	 * 移除缓存(直接操作一级缓存)
	 * @param key
	 */
	public void removeFirst(String cacheName, String key) {
		CacheClient.getInstance().removeFirst(cacheName,key);
	}

	/**
	 * 移除缓存(直接操作二级缓存)
	 * @param key
	 */
	public void removeSecond(String cacheName, String key) {
		CacheClient.getInstance().removeSecond(cacheName,key);
	}


	/**
	 * 批量移除
	 * @param keys
	 */
	public void remove(String cacheName, List<String> keys) {
		CacheClient.getInstance().remove(cacheName,keys);
	}

	/**
	 * 批量移除(直接操作一级缓存)
	 * @param keys
	 */
	public void removeFirst(String cacheName, List<String> keys) {
		CacheClient.getInstance().removeFirst(cacheName,keys);
	}

	/**
	 * 批量移除(直接操作二级缓存)
	 * @param keys
	 */
	public void removeSecond(String cacheName, List<String> keys) {
		CacheClient.getInstance().removeSecond(cacheName, keys);
	}


	/**
	 * 清除cacheName内缓存
	 */
	public void clear(String cacheName) {
		CacheClient.getInstance().clear(cacheName);
	}

	/**
	 * 清除cacheName内缓存(直接操作一级缓存)
	 */
	public void clearFirst(String cacheName) {
		CacheClient.getInstance().clearFirst(cacheName);
	}

	/**
	 * 清除cacheName内缓存(直接操作二级缓存)
	 */
	public void clearSecond(String cacheName) {
		CacheClient.getInstance().clearSecond(cacheName);
	}
}
